Come segnalare in modo efficiente finestre scorrevoli con una lunghezza fissa in pochi secondi

Penso che tu intendessi incremento basato su "Per ogni finestra di lunghezza 2 secondi a partire da un secondo confine" e non sovrapposizione. Per intervalli di due secondi, è lo stesso, ma poiché vuoi variare la lunghezza, una sovrapposizione di un secondo sarebbe 0-3, 2-5, 4-7, ma un incremento significherebbe 0-3, 1-4, 2- 5. Tuttavia, è stato interessante trovare soluzioni per entrambi per ogni evenienza.
Supponendo che L sia ordinato e tutti gli elementi siano positivi e che i secondi intervalli inizino tutti con numeri interi, possiamo usare questo metodo:
importa matematica
dalle collezioni importa defaultdict
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
my_ranges = defaultdict (elenco)
larghezza_intervallo = 2
per x in L:
upper_bound = math.ceil (x)
lower_bound = upper_bound - interval_width
lower_bound = max (0, lower_bound)
per y nell'intervallo (lower_bound, upper_bound):
my_ranges [y] .append (x)
per un in ordinato (my_ranges):
print (my_ranges [a])
Non so se vuoi vedere se ci sono intervalli vuoti. Ma il defaultdict stampa anche intervalli vuoti, se lo desideri. Usa questa riga invece di "for a in ordinato":
per un intervallo (min (my_ranges), max (my_ranges) + 1):
Se vuoi gli intervalli 0-3, 2-5, 4-7, funziona:
importa matematica
dalle collezioni importa defaultdict
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
larghezza_intervallo = 2
my_ranges_2 = defaultdict (elenco)
per x in L:
sicuramente_in = (x // (interval_width - 1)) * (interval_width - 1) # il multiplo più basso di interval_width sotto x sarà sempre
#print ("Aggiunta", x, "a", sicuramente_in)
my_ranges_2 [sicuramente_in] .append (x)
se x  = 0: # per esempio, se x è 2,3 e abbiamo 0,3 2,5 ecc ... dobbiamo prendere questo caso duplicato. Suppongo che le lunghezze delle finestre siano numeri interi e, in caso contrario, abbiamo molto altro da fare, perché il numero può essere contenuto in più di un array. Forse potremmo avere un ciclo while, incrementando di (interval_width - 1)
#print ("++ Aggiunta", x, "a", sicuramente_in - ampiezza_intervallo + 1)
my_ranges_2 [sicuramente_in - interval_width + 1] .append (x)
per un in ordinato (my_ranges_2):
print (a, my_ranges_2 [a])
# print (my_ranges_2 [a])
Sospetto che ci siano alcuni dettagli che ho dimenticato, ma si spera che tu possa modificare interval_width come necessario per assicurarti che il mio codice stia facendo quello che speravi e fammi sapere di cosa hai esattamente bisogno.
|
Una possibile soluzione che posso proporre è "efficiente" in un certo senso, che itera solo una volta attraverso i dati di input e non ha dipendenze. Il costo, ovviamente, è che è scritto in puro python (potrebbe esserci codice più ottimizzato) e che introduce più variabili di tracciamento per prevenire la ripetizione (e quindi è meno pitonico).
def scorrevole_window (dati, durata, inizio = 0, sovrapposizione = 1):
risultato = []
data_idx = 0
result_idx = 0
superiore = inizio + durata
inferiore = inizio
next_lower = upper - overlap
# helper interno per riempire elenchi interni vuoti fino al nostro punto di inserimento e inserimento
def pad_and_append (at):
while len (risultato) <= at:
result.append ([])
risultato [at] .append (data [data_idx])
# itera i dati di input
mentre data_idx  a:
se x  = l [0]) & (L  = i) & (L